tclab/FOPDT fit.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FOPDT fit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "My tests of my TClab around $Q_1=50$ have resulted FOPDT model with $\\tau_p=150$ s, $K_p=0.38$ and $\\theta=15$ s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tclab import runexperiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "steptime=1000\n",
    "Qbar = 50\n",
    "deltaQ = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def steptest(t, lab):\n",
    "    lab.Q1(Qbar if t < steptime else Qbar + deltaQ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TCLab version 0.4.6dev\n",
      "NHduino connected on port /dev/cu.wchusbserial1410 at 115200 baud.\n",
      "TCLab Firmware 1.3.0 Arduino Uno.\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAAXNSR0IArs4c6QAAQABJREFUeAHsnQlgXVW1sFfmoUPSNp3TNp0nWmgLLS2TyJCCzCAKggyi8ovyfnFCBOWhPn1O7/cpPuEBFlBElMqMQQWZh1Ja2tJ5SNt0TIckbdKkmf61Tu5Jzr2592Zobu70LV05ezr77P3t0K7uYW0RBAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgkHgEUhKvS8fWo/T09OahQ4ceWyW83asE6urqJCsrq1e/yceOjQBjdmz8ovU24xYt8t3/LmPWfXbRenPHjh1H9dsR/0stPVodjNXv5ufnS1lZWaw2j3YFIVBSUiLFxcVBckiKVQKMWayOTPh2MW7h+cRiLmMWi6MSvk0pKSnl4Uv0TG5qz1RDLRCAAAQgAAEIQAAC8UKAGcB4GSnaCQEIQAACEIBARAjsO1wn//X39ZKemiJfL54s/bIzjvk7H26vkEVvlcrkYf3k5jPGH3N9PV0BBmBPE6U+CEAAAhCAQJQJNDU1y/Mrd8nSXU1yRn2jZGek9UiLjhxtlGdX7JQ+mely3nHDJFUNpkDZUXFE/rF6jxw3Mk/mjBkQmC1VtfXy/IpdUqftOnvaUEnTOl76aI+MGZQruytrpVbTJw3tJ69uKJeK6nq58qRCrWegU09zc7OUfLRbyg4ekfFD+sreqlo5VNsgQ/pnywUzhsvrG/fJsm0HZcOewzKzME+WlB506t12oEbbnOa0qVHZBKZbfXUNTc43vvv0R/IJrat0f3Vr261PtfVN+q16GT+4r2RlpOp3KmTe2IHOe9YHY/PRzioxJHM1/enlO533N+49LDV1DdI/J0N2af+sLSY5OibWxmgJBmC0yPNdCEAAAhBIegJ71IAx48KMijw1ELxiRty6PYdkcL8sKejbcibAypfuazFM0tNSZHDfbKk4ctQxmGrUALH8yWo8faBG0P2vbZbKqiYpeH2znDV1qBxRw8org7XOvYfqpKGxSTLSU8W+p/8XM7LS01IlxWfb1athZN/SYmqo7ZZ3txxwqtEiTtsaGpud9926v6cGlMlflpbJ9y6c1s5IfGLJdsdQsjJPqZFkBlk4ufuZ1XLXBdOcNpgx9ejbW4MWX7/7kLy6vm37nGtoGRNXNpW3GXXedDffnvaNX/5zgzfJL7x1f4sBZ4mukedXIEj6K+va2uUtu8U3lt603gpjAPYWab4DAQhAAAIQ8BDYe6hWbnr4fSclPzdDFt0w15kNc4ssXrZDHn6rVDLU+Hrkc/OcmTG3vFvGfY4t6OMYkkfVWLt63mg1THa4WTpjtsfR1oQeCtz7yqYOa/r3Z1eHLdOR8ee+/P3nwtdj5bzGn/teV579stOd2UTvOzN0hu6jHZWOYexN70x4wYRB8tbG/Y5xXtAvU5ao4VyvxnKgWDmvPOeNRDCMARhBuFQNAQhAAAKxT6Bal+e+vXil1Bxt0NkvkaM61fV/dM/WCaPznfTNnlmjUL3J0hm0VJ0ya2hq8vtL3k0PnH3L1PJmrLlSUVMvl9z7prMs6Ka575jRcNX977jJQZ/emaTH3t0WtIwl2rKjW2/IQt3MsLpN6pWBzQqauGlOxPPDbYPlBzLzFGsNeutp1EEydpZmHM1w21+tnlN8tpXVbbOplm6zfF6j6+6Lpsl6XR7+8/vb26XbMrMtTf/+na3OrOSsMfly+8IpUnWkQe54aqVs8838LRg/yJn5DDX7Z42+6bSxcvEJI1vbbwFbPv7mX1Y4y9duxnc+MVVOHudvAN7hZkb46ZvgjfBX4qj6goKC5vLy4FO1cdSNpGoqbg7ib7gZs/gbM2txpMetXg0v+8vX9lp95uTR0j/MRnzbb/XoO6Wy//BReWvTfv1LdKB8/vRxsmlvtTMT1OxaA51AvWxrRVCjKFf3jNmyajzLgOYqOZjS3+nCZ3Rm8NNzR8tBNZau+917jrHr9m3a8P6yeleVGxXr+6M66/gfL6yRpVsPtqaHCnxB2V94/IhQ2aR3gYC6gbHp28IuvNKtoswAdgsbL0EAAhCAQEcEDqihsXz7Qd3onu/MxrynS2A2S2ZGlc2M2cyPO1NkdS3TU5NvbNjnVLt2d5WzET/UN2y5b0VZZWv2O5sPyJpdh6TySH1r2rEGumL82WzU7edPkX9/5iO/5cJsPSxgBm2g2MyVzf7YLIzt7yvXU6jBxN1/p0aBk23781xmI/JzxE6v2myY7eGz2Ut3P58Vtj1+q957TUbPnOFwt72BJgP6ZMoDnz1RynTvoZUxZlP0pOoe3Q9ohnVdQ6OM1Lqtjd/WPq3TvXUDcjMdI3l4XrbYHjgzEO29QX2ypFbLT9QDGUh8EcAAjK/xorUQgAAEeo1ARc1RNVBSnCW9DN3xX13fLGbUNZml0Qn56p+Wiy1t9slKk1PGF8hLejK0s2LLrr96eWNnizvlvMbf6IG5MkuXcDsrdvq0WpeAB/fLFltOPd53OtPSD+sSsS0rjhqQq31JdwwjO6lqxpMd0Cg7WCPF04c5J1Hvu/ZE7edu551+WtbSzQD859o9zsnZwf21vJ4CPVfTh+rJVVdGaXu7Ix29t1oNx+kj2p80tVOzpiajfB82oy9QstLtpKo/Rzvdi8Q/AQzA+B9DegABCECgxwk8+MYWeUoPIXilsqpRfrflPW9Sp8LVdY1hjb9RA9sMj+0HjrTW6U1vTfQEbDbRjBZbAjZxyw/Py5FvqC+3nnJ94vlkh8FhOkP22flF7crdcMrYdmkkQCCaBDAAo0mfb0MAAhDoJQK2v+5X6trCdUdhJ0vPmDRETioaIH9VQ8821nvF/KhFWsy1yA8uOc5vhurRt0vliffL1F9bf/nRZTMj3QTqh0DSEsAATNqhp+MQgEA8ErD9WX9btVve1lkvm+myk6vmwNb2ZvW1U4+6ZGnGnO0P88oqdWWxakfbJn87GfmPNXsc9ZbrTPi2cybJdDXQOiOZunRsp2pN3LCd0DTnvbZvzpZUvXKtzp5dMHNEO5943jKEIQCBYyfg/1/esddHDRCAAAQg0A0C5g9tU/nhDp3i/l330Zma2K0DPSWj9RaGc/VWBq/YXjjbPzYiv2Vf3IcffihnLpgiJ48d1M65r/e9zoSz+oa+mcIOKSAQgEBkCWAARpYvtUMAAhDoFIGflqyTN/Uaq56U2QGHIOxWCduPZ2KHF0YNaJklNIPrc6eODXv/qRmCGbtWygI9zIFAAALxTwADMP7HkB5AAAIxSMCcvt751CpxnQib2wwTcy1i96dmq4sNr3TF5Yj3PTc8dXg/ue2cyXL74hWOG5L/uPQ4KdRTqwgEIACBYAQwAINRIQ0CEIBAGAJ2u4DdJGBGmx2d2K++2Ny7Ws0VifmnMz937uXyVpXXwLM7V73xYJ+y939/07wun2S168QQCEAAAh0RwADsiBD5EIBA0hLYoY5yN+u+PPOBZ05x7cowk4fURco+vYHCXw75Rb3Gn2VMVke75lDXleLpQ2W+XinllbyczBafc2pYWvlouDHxtocwBCCQuAQwABN3bOkZBCDQCQI2G2c3GQSKzdDd/OjSwOSw8YXHDXNO6LqF5owZoDN9DXL8qHznZOt2dQBsp3cH6p47uzbLjEoEAhCAQDQIYABGgzrfhAAEYoKAzeh95Y/LpFyvwOqsDOrbckI1W29I+OSJhfLCyt1yUG/MOH/GcLliTqHOFqbIktKDcp26Mzl1ov+BiTy9QYFbFDpLmnIQgEAkCWAARpIudUMAAjFBwO6g/euystY7VN1GrfUsybpp4Z7nqJuUW8+a6FfkrKn+rlO+cPp4+cLpfkWIQAACEIg5AolkAH5P6d6tOkN1lar9Kf2wqv0TvEL1etXVqggEIJCABLbpBfXvbNnv+NE7rE6G7aDGeN8F9Y+9u63DHt979eygZexqLzvRa3fBBrsrNehLJEIAAhCIcQKJYgDan9wnq3r/lL9P4/erLlK9QvVB1fmqCAQgEKcEGvRGiT26XNtXb4+orKn368Utj33gF7fIuzrz5xW7LeO8GcO8SU541qgBYo6QQ8mgvlmhskiHAAQgEJcEEsEAtD+Z71W9WvUV3ygM0acZhef64k/q89eqRaqlqggEIBCHBL715EpZr86MuyLHj8pzig/MNWfH4yQvN6Mrr1MWAhCAQEISSAQD8B4dmd+rbvGM0CgN71Rt8dkgjqsumx0crVqqikAAAjFCoEIPUHz36Y/Erh3zinvYwpu2v53rFW+ufzhdD2PYnbWnTRzsn0EMAhCAAAQkJc4Z2JLuD1XPUjV/rKWqF6jarOAjqtNVXVmiga+pvuYm+J636dPUkdzc3JGLFy92ozzjgEBtba1kZ2fHQUuTo4mlVc3yclmTcxvF8D4psqGiWYb3EcnLTJFhusq6q0bkaH29pKe3zMR9dKBJ6pu6zmZYbopcOznV70W9YMP5rnlXUe8ukm4JSI8R4L+1HkPZaxUxZr2Gusc+tHDhwh1aWWGPVRiionj/0/F27detqq5HVgNmt6TfofrfquZl1WYBrZ+7VG2fYKlqSCkoKGguLy8PmU9G7BEoKSmR4uLi2GtYArTIfOSt3lXl9MRcpkzQQxWl+6vlyNEmdVhcr7ddpOm/vJrlaEOT7svLELO3fvTi2g57XllVKXn9W5ZmwxX+5sLJftnNatRV6YEMW86dUZgX9u5avxeJ9AgB/lvrEYy9Wglj1qu4e+RjKSkpvWIAxvsS8I+VtqkrpRqwGUA7BXyD6jWqi1QvVy31qT4QCCQ3gWa1pPQPGbFnOHltQ7n8/KX14Yp0O+9sj/uUTXrbRqMamzeeWiRVRxrE3LNcdMIITt12my4vQgACEAhPIN4NwHC9+6JmLlK12UCbwrhOFYFA0hO495WN8tLqPTpjl6ZXmzU6hldPQbHTuYd916WNyM9Wx8ijnDtzczJ1plBtzQq9J3eQ3oKxoOiwfPLsiSE/e+YUO8eFQAACEIBApAgkmgFY5AG1TsO4ffEAIZjYBFaUVchTy3bqYYrDMmpgrpgvvA17D8tMXSpN8+yFW7bN3GLqv4p0pq0nxVys3HftHGdm0VuvOU8OFFuWQiAAAQhAIHoEEs0AjB5JvgyBCBOwJdI3N+5zrh1zP1Wne+92VdRKUUGuPPD6FjdZ9nlOy64oq2xNDxY4Vw20eq37lbV7nezPnz5Ol16z5e5nWvymj1Zj8itnTWh9tU9mugzulyU7Ko44/vgsw2b9zEmyLSsjEIAABCAQ+wQwAGN/jGhhEhCoOdoglbo82tAYek+eGX9/6MSNFsFwXTXXPCC1SENTk6zRgx12J21+TqacPW2Iszw7aWhfMePuY5MHO4bc3RdNl1J1zXLW1CGSr4cuAmX84L6tSe3n+FqzCEAAAhCAQAwSwACMwUGhSclFwPzgXffQe47bks72fNLQflKrV5NtO6A+VXwyUU/o2pKv+c+z+2ltr92r68rlYj1MsWCC3YgYXi6YOcKvwJwxA8QUgQAEIACBxCOAAZh4Y0qPYpDA08t3yHMrdskQXTrdd7hO6nWmr1yvNLOlVHt2Ra48sVCunV/knOC9468rZfXOKj09O1YNvZHtqjl/xvB2aSRAAAIQgAAEMAD5HYBADxPYqn7yXtb9dLZnz/bomfxt1W7nubuy1nm6P4IZf49+bq6kp/k7OHbLp+keOztRa2L77f7j0hnON7IzWtLccjwhAAEIQAAC4QhgAIajQx4EQhCw5Ve7k9aWYu0AxNb9Nbp/r0ky9AqK7+m1Zl0RW6IdM6iPzgo2OUuuwfbbharPjECMv1B0SIcABCAAgVAEMABDkSEdAmEI3PXUKsdZsXszRrjDG95q5o4dKAN1b57tz9uiM4WjBuTK1XpAI9XjpsVbnjAEIAABCEAgEgQwACNBlToThsADr2+WZz/c6Vw07e2Ue4HGRj10ESg5uhzbPydDD3U0O774juhsYR91uvxZ3bfHnrxAWsQhAAEIQCAaBDAAo0Gdb8YkgaVbD8oLK3fpcm61FOrMnImldUWumFMo1y0o6sorlIUABCAAAQj0OgEMwF5HzgdjgcCqHZWOI2NvW3798sbW6J4q/5O5n50/RqaPyGvNt0Cz/i9F/2cypH+WVNTUy/jBfZw4PyAAAQhAAAKxTAADMJZHh7b1GIGq2npp1gO59eoE2Wb43Fsuwn3g0lkjnUMdw/pny1l6N21H+/QK+maFq448CEAAAhCAQMwQwACMmaGgIZEi8KIu6/7mX5uCVm/XnLlS19AoNvPXNytd9+oNc3ztuXk8IQABCEAAAolEAAMwkUYzyftiy7oPvbml1feei2ObumgJJnYi964LpgXLIg0CEIAABCCQ0AQwABN6eBO7c0eONsrzOrv35tYm2amG3+IPdnTY4ZOKBsr/+dh4daIsjiuWDl+gAAQgAAEIQCABCWAAJuCgJmKXjuqNGpv3Hdbrz9p6Zyd2/6V33VZWNclGj/HXLzvdcbnSVlL0urVaGap7+U6bOLj1Jg1vPmEIQAACEIBAMhHAAEym0Y7jvn5H77xdu/tQhz04e+pQuWruKD2Vm91hWQpAAAIQgAAEkpVALBuAD+ugXJesA0O/1c2KTvd9/7k1smpnpdhybzgZ1DdTfnzZTBmWh+EXjhN5EIAABCAAASMQywbgmQxR8hF4e9N++Z9XN4ndjDaoT5Zz324wCt8+b4osmFDgZJWUlEhx8dxgxUiDAAQgAAEIQCAIgWgbgHuDtMmS9K9/yQ+RR3KCELAZvlU7qmTrgWqp0Rm+AbmZ8t//3NDau/2Hj7aGv1E8WdJ99+Xa8i4Ol1vREIAABCAAAQh0mUC0DUAz9M5SrQxouaW/GZBGNAEIHFKHzLmZ6VJ5pF427DkkP3h+Tche9c9Jl49NGqI3cPRvne0LWZgMCEAAAhCAAAQ6TSDaBuBSbekg1RVBWrw7SBpJcUzg2Q93yv2vbQ7bg5zMNGe/37Th/eWOT0yVvJyMsOXJhAAEIAABCECg6wSibQBerk2uD9HsOSHSSY4jAhU1R+V/9BaOA9VHw57itdXdby1s29cXR12kqRCAAAQgAIG4IxBtA/ABJXZV3FGjwR0SWLr1gC7xHpaSj3bLPs9ePu+LP7liptjpXZvlq1M/f/2zme3z8iEMAQhAAAIQiBSBaBuAUyLVMertXQLmqHnr/moxP822v++eZ1e3a8CNpxZpmRoZpoc4puoSr6krWelpbpAnBCAAAQhAAAIRJhBtA9Bzr0OEe0r1ESVw+5MrZMPewyG/cfdF02XOmAEh88mAAAQgAAEIQKD3CETbAJyhXQ3mCsZOAZtxOKT3UPClrhJ4Y8M+uf/1zXJQ9/eFkjTd3HfzGeMw/kIBIh0CEIAABCAQBQLRNgDXa5/Pj0K/+WQ3CdiNHH9ask2e1hO9DY3BJ3Btb9/kof1av5Dq89/XmkAAAhCAAAQgAIGoEoi2AVinvd8aVQJ8vFMEGhqb5MOySnluxU55v/Rg0HduOKVIZo8eIEUFfYLmkwgBCEAAAhCAQGwQiLYBaEu9SIwSsNm+FB0h0z++u02e/GBHu5aeNrFAr21LcZw1nzdjeLt8EiAAAQhAAAIQiD0C0TYAZ8UeElpkBH704hp5a+P+sDCuX1Akl88pDFuGTAhAAAIQgAAEYo9AtA3A2COSxC2yu3kffGOLPL18Z0gKN58xXj4xk5m+kIDIgAAEIAABCMQBgUQwAF9SzsNUm1QPqX5FdbnqRNWHVQtUK1SvV23vnE4TEVFnzXXy1LIdIY2/K08slHOnD5Oh6sMPgQAEIAABCEAgvgkkggF4pQ6BGXgml6g+pDpb9T7V+1UXqV6h+qDqfFXER8CcN++pqpX0tBS566lVGq7zY3PTaWNlYJ9M57Sv7fVLT0v1yycCAQhAAAIQgEB8EkgEA9A1/mwE8lRtJtD8B5oReK6qyZOqv1YtUi1VTXppamqWr/zxA9lZURuUxUXHjxDTFDsBgkAAAhCAAAQgkFAEEsEAtAF5RPVM38gs1OcoVdvI1uBLM4d121RHq5aqJq3UNTTKD55bI8u3e+3mFhw5mWny48tmyLjBfZOWDx2HAAQgAAEIJAOBRJveuU4H7VOqd6maUThd1ZUlGvia6mtugu95mz5NHcnNzR25ePFiN5owzzp12vzmrmZ5e7dNkLaX0X1T5KpJqZIeh06ba2trJTubvYntRzV2Uxiz2B2bcC1j3MLRic08xiw2xyVcqxYuXGg+1yLuYiPRDEBjekS1SNVuGRmkarOA1s9dqierlqqGlIKCguby8vKQ+fGWYQ6cV+6odA53LN3a3oHzqIE5cs28MXLC6HzJzYzPCeGSkhIpLi6Ot6FJ6vYyZvE5/Ixb/I0bYxZ/Y6Zbr3rFAIzPv/HbxrO/Bm290vVbcqmGzXmd3S+8TPUa1UWql6uW+lQfySNPvF8mf3zPVr/9Zc6YATI8L1sunT1ShvRj9syfDjEIQAACEIBAYhOIdwPQDn3YAY8cVVvbtKm7C1Rtz98XVRep3qFapWrLw0khew/Vyq1/XCbVdY1B+3vjqUVy6ayIzy4H/TaJEIAABCAAAQhEn0C8G4DbFeHcEBjXaXrSuX156aPd8quXN7ZD8oXTx8mFeqoXgQAEIAABCEAAAvFuADKCPgLVdQ3y5sZ9QY2/X189S0YPzIUVBCAAAQhAAAIQcAhgAMb5L8Kh2nqpqm2Q3+kVbu9uOdDamxH52TJe3blcOmukjBnUpzWdAAQgAAEIQAACEMAAjOPfgdJ91fLVJ5Y7N3V4u3HW1CFy68cnSmocunTx9oMwBCAAAQhAAAKRIYABGBmuEa/VTvY+9q7/6d40Nfi+WTxZFkyw648RCEAAAhCAAAQgEJwABmBwLjGX2tzcLCV6wOPZFbtkytB+8tLqPX5t/MPn50mm3tWbnZHml04EAhCAAAQgAAEIBBLAAAwkEqPxj3ZWyb2vbHJat21/jV8rc9To65+d4ZdGBAIQgAAEIAABCIQigAEYikyMpf+/f9jFJm1ijpwP1hyVkfk5cva0oW0ZhCAAAQhAAAIQgEAHBDAAOwAU7eyfv7RO/rXO/2q6MycPltvOnRztpvF9CEAAAhCAAATilAAGYIwOnJ3w/eOSbfLWRrvZrk1+dNkMOW6kXYCCQAACEIAABCAAge4RwADsHreIvVVZUy8fbDsov/i7/5Kv+0GMP5cETwhAAAIQgAAEuksAA7C75CLw3pGjjfKdp1bK1oBDHpfNHilZ6WlyKu5dIkCdKiEAAQhAAALJRwADMEbGfNWOSvnu06ukvrG5tUUTh/aVL31svEwY0q81jQAEIAABCEAAAhA4VgIYgMdK8Bjeb2pqFjvdu0Vn/GzPnysZaSnys08eL+P0KjcEAhCAAAQgAAEI9DQBDMCeJtrJ+szge/jtUnm/9KDfG5OH9ZN7Lp4uuZkMjR8YIhCAAAQgAAEI9BgBrIweQ9n5inZVHpF/e3yZ6ARgq3zxjHHOPr954wZi/LVSIQABCEAAAhCAQCQIYABGgmqYOt/dvF9+8PwavxK3njVRzsGZsx8TIhCAAAQgAAEIRI4ABmDk2LbWXN/Y5BzwWLWjqjXNAgP6ZMqP1a/fCL3NA4EABCAAAQhAAAK9RQADsBdI/3PNHgk0/s6eOlRuPWuCpKSk9EIL+AQEIAABCEAAAhBoI4AB2Maix0N2yneFune595VNfnXfft4UmTt2IMafHxUiEIAABCAAAQj0FgEMwAiRPtrQpCd8D8iPXlzr94VvLZwip+DQ2Y8JEQhAAAIQgAAEepcABmAEeNtBj//821o/p85T1L3LV8+ZxH6/CPCmSghAAAIQgAAEukYAA7BrvMKWtjt8/7K0TFaWVfqVO3PyYLnt3Ml+aUQgAAEIQAACEIBAtAhgAB4j+TW7quSFlbskJzNNXly526+2mYV5cvMZ42Ukp3z9uBCBAAQgAAEIQCC6BDAAu8m/ublZSvUKt2/+ZUW7Ggaqe5crTxwlp08qkH7ZGe3ySYAABCAAAQhAAALRJIAB2E36jy/ZLo+9u63d26dNLJCbThsnZgQiEIAABCAAAQhAIBYJYAB2clQ2lx+Wr//5Q+dgR0Zait8BD6vCnDr/+upZ0p8Zv04SpRgEIAABCEAAAtEigAEYQN6Wdh95u1SXbtPlkhNGynMrdskT72+Xipr61pL1jZ5LfDX18tkj5boFRfj1ayVEAAIQgAAEIACBWCaAARgwOjUNIn9+v8xJXaGned8vPRhQoiV65yemypH6RsnPzZQZI/Mw/oJSIhECEIAABCAAgVgkgAEYMCreyb1gxl9ORprcc8l0mTKsf8CbRCEAAQhAAAIQgEB8EMAADBgn7828+bkZfku/c8YMkO9eME1SU72lAiogCgEIQAACEIAABGKcAAZgwAD1y0yRZ79yakAqUQhAAAIQgAAEIJA4BFITpyv0BAIQgAAEIAABCECgMwQwADtDiTIQgAAEIAABCEAggQhgACbQYNIVCEAAAhCAAAQg0BkCsbwH8CXtwDDVJtVDql9RXa46UfVh1QLVCtXrVVerBpM7NfEGX8Zj+rwrWCFvWkVFhRQWFnqTCMc4gbq6OsnKyorxVtI8LwHGzEsjfsKMW/yMldtSxswlEVfPkb3R2lg2AK9UAGbgmVyi+pDqbNX7VO9XXaR6heqDqvNVA+V0TbhKdaaqeveTN1XfUC1RDSn5+flSVlYWMp+M2CNQUlIixcXFsdcwWhSSAGMWEk1MZzBuMT08QRvHmAXFEtOJKSkpjb3RwFheAnaNP+OQp2ozgUNUzQj8varJk6pjVYtUA+VTmrBItVq1TtUMSDMIEQhAAAIQgAAEIJDUBGJ5BtAG5hHVM30jtFCfo1R3qtqMnondybZNdbRqqapXLO1VT0Kphm3GEIEABCAAAQhAIEYJVNc1yL2vbJRGvZr1S2dMkDz1yWtSc7QlvaHJPz2wGzsrjsgDr2+RAfrel86cIOa698E3tkjZwSNy0QkjpGTVbklPS5EvnzlRcjLTAl+X1Tur5LH3tsqaXYdk6vB+Mjwvx3n3nGlD5ONThspflpbJsm0H5dMnjZYZhTY/1V6Wbj0oT35QJut2H5Lxg/vIuMF95YZTiuTelzfK7qpaOWVCgVys180eqq2X3/xrk7yxYZ9TyY2nFrWvLEIpiiUu5Dptpc3o3aVqRuF0VVeWaOBrqq+5Cb7ns/q0sn/2xT+hTyv3cV/cfdymAVNHcnNzRy5evNiN8owDArW1tZKdnR0HLaWJLgHGzCURX0/GLb7Gy1obj2O2+kCT/HWzLfqJfGJMqpwwONUJr9H0xb708zV9li/dyfT8eG1nk7yuanLdlDTpo/bjb1a2X1W9fHyqTBnQUrfndXl0baNsO2zzS+3lW7PT5D8/aKlrWG6KfG5aewPS3vof/d6BOv86zi5MlX+UtbTLvvqtOWny0YFmeWZLS5r7tdfvvKBSw/luPFLPWJ8BdPv9sAZ+q2qb8+yEhrXbZgHNgB2luk01UCytyJM4RsPByv1C000dUQOwmf1kLo34eLLHJT7GydtKxsxLI37CjFv8jJXb0ngcs8y1e+XlfeudLsw4frwUzxjuhLPW7ZV/+tKPmzlOimeOcLvp99zzdqmsOGzmgsi8k2dIXk6G/GHrB07c+2PW7Mly+qTB3iQn/My+DyQvtaZduiWcdfZ8+e3Gt528LJ1hLC6eF7Tc/2x8U/Ky/A3AiVNHy5KqNjOk+NxTJG3NHnl1/8bAOg4HJkQiHqsGYH/tbF9VW+41uVR1v+pe1WWq16guUr1ctdSn+vATm/n7tepvVM1YvFH1TlUEAhCAAAQgkJAEmnR5tEqXFfNzM/36FyrdCh3WJde6+kYZ1DfL751QEStfa+X7ZErlkfrWYrmZ6U5dtvRaUVMvabrM2j87Q5p1KXff4aPSNytd0nQ9tuLIUcnPyRRb6rXlXPufvWv51s6DNUdb66xvbNK6jspRfVbV2l/lLVJ+qE6ONmie1pWZlurkW46Fq+vaZvusLns3mFjeweqjUt/kn1/X0PZ+4HvWL1csvO9wnTRp/9w2ZKSmOnvTGrUfgeJlZXnl+u4hT58Cy0c6HqtLwDarZwc8clRtZMpVv666XHWy6iLVQapVqtepfqRq8oLqd1Xft4iKha+3gMrjqnc4oTA/CgoKmsvL7XNIvBCIx3/hxgvbSLWTMYsU2cjWy7hFlu+x1m6G1lf/tFw2lVfLtSePkStPGiU2Zueee6587YkPZcPew3LNyaPlU7p3zRXby3b3s6sdw+sTM4fLzWeMd7OCPleUVch3n/5Ighk4gS/Y3ruvnTtZ3ty4T97aZHM4oSVVC3/vwmny5/e3y6od9ld78spzt562Q3tfGGkCsToDuF07PjdE59dp+vwQeecHpN+jcVMEAhCAAAQgkNAEauubHOPPOvnCql2OAWjhOp0pM+PP5PmVu/0MQDukYLNuJit32Naz8LJWD0Z0xvizWqza1buqZNXOjuu1NljdyW78haffs7mxagD2bC+pDQIQgAAEIJBEBIKsQDq9t1nCeJUfXz5Dbn9yZcjmD9AlaVvSNbn/s3PkC48sDVnWm2Ezn1fM8Z9w++U/Nsjy7S3e6O6+aLrc/Yy70Njy5gX6znMrdnmrCRu+WE8fP728ZVfbLWeOlxOLBraWT9fZTzuNbAa8LXkPvrU1K6IBDMCI4qVyCEAAAhBIBgLbD9To7NouZ3bsvOOGyRHdI/eRuhNJS0lx9ogN0D15Z0we7OT/Sw8z2D412ztm+8Jsb1vhgBynrG4hk1PGFzgzeWt3V4ntdSsckKvxw7qXTmTKsH7SLztdFmiZtzfva90Xl6rfsX15rpghZMupH+1ukn3qjsQV27f2pLoxsbrHFvSVP763zc2SKm3LE/rOln3V6vokW7Iz2p9wNRcoXZGNOvNYp4ZNZ2T1rvAzhcYwnGTqnkNX+unew85KjvazIGD/Y/+cNvOooG/77/bXgyVdkT66v9GVdB3kwO9ZXlZ6e97uO5F4trUoErVTJwQgAAEIQCAJCHz36VXOQQfr6t9X73EOO9ghBa9kZaTKfj0MYT7pwskTS8qcwxTByiwpPeAkm4+5PVV1wYq0pj3y9laprGqSpVW2q6pNFr1V6kTe2dxSl5tjxuGj+k5Pii0xdyS2V9BmLD/cHt4ANN99dqI38DCF1W9GmhmILhMzvDsrVm+gZHuMsXQ9WDK0f1Zr3VbWjMauiLd8sO91pa6eKosB2FMkqQcCEIAABJKWgJ1ydcX2yAXbJ2eGSzDjxX3Pfdop247ENXTs5Kx9y2Ycj1WOG9nfbw/eZJ1tzPAYRzYDabOargSWd9PdZ1FBHz3Z22IobdMZ0pH5Osup1p53n5/NfN502jhdHt3hLH8e0JnLnRW1bhV6OjhNHUA3yidPLJQh/bLl386eKM/oUur6PYfUuXIf2awHXiYN7SeXzBqpM5ap8sSS7TKzMN9ZUv1G8WR5afVuGT0wVw+i7Ber28RmUXeos2g7gWvhs9S5c6CYk+YKHa8R2uYROhtqDqV//OJaOaJtsYM0Z04ZovsqDzmztha25V0zQndW1srKsjZDdkR+tnxs8hA5a+oQsdlQs0u9y7+B3+3NOAZgb9LmWxCAAAQgAIEeJGBGmhmMnZlpC/fZX376BOe2itueWC4b9rQcGPn2eVP8XMPY/rTLfvOWU43NaP3ospmOG5QbfrfESTNjaq1nxu9XV80K+skHXt/cuh/ODLopw/rLnDEDWste+Ks3WsN/+qL/mc+TdO+caSj594vbbuYwH3+un78vnD4+1CtB00cPypW7LpjWmjd79AB5IqAt3yie0po/S/M7kq+rQRpLggEYS6NBWyAAAQgkKQEzYu5/dZO8sq7FDdfxo/LkM/PGyIu6r872yA3ulyU3njK29equV9eXyyvqMNjErtqya75sJuhy3cy/dOsB+flL61t9rJlxYdeI2dVeJ4zKl3OmDXXK/urlDbLCN1tj37O9WTYzZDNV7tPqt2u93Jkor6FieV2R+17d7CwlduUdykIgUgQwACNFlnohAAEIQKDTBN5RP3Gu8Wcv2X6wj3aulIZGXXf0yYyRea0zOjaL5DrlNQPNxHzNna3G3X/+bZ2zVOd7zTHg3LCd7CzdX613ug5pNf4sz7v/bLcu45m4TwvbMqSJ+y0n0o0f7tJtN14N+oodCOkJ6eurp1CNX3cGMPCeXO++uknD7K4G/71wtlxqnGy517vnLbB95hzalWCHNdx9frbvDokcgZ75zYlc+6gZAhCAAASSgIAtLwaK1/izPG+ZwAMW7rtWxvZpeWWs7kWzk62uWJlQ77tlQj1tD5vNMgaK+bEzP3rb9te07scz58afP22s/En3pbnG6rTh/WVGYZ5zAtjqqteDIua+xPa3rVGfeaYzdZbSEd10Zzdk2HLkP9fs1dsmUpyTxJv2Vkud9iFLDyfY/rMGvcniVZ05XaHfH6r17K46ooclMnW/nV6hVXZIjps+yjnRW6T12BKt7RnM0MwJQ/rqzGmNDOuf7Xzfvnm9zrIW6p658YP7Ot9uaUjLT+vPjy6boYZ5pbOvzVLtdOvdF01zTi2fM3Wosxz9hjp+Pqko9JLo+epCJSM9RW8SyXJmW73fsPA9F0+Xd7cccE5DB+YR7zkCGIA9x5KaIAABCMQlATOYAmd7GtTAUDtBMtNTHfcidtWVV8zgsSu2sjS/Wt/P1meK7nC3wwjm18yu+HJnjKwON93qsLxAqQ1z/ZZb1vykmasTe9+cGweTYOlThvfzMwDt815jMlg9odLsQIHdshFKturs4pcfsxtLRU6dMEgu0PtqR6kblzufWuWkHafG3zUh3p8/3i64Ci7efW9zxrTfA/fpuaPl00FeLSnZKsWe7wUeQJg71r+ugWqMXnniqCA1tSQdp7Owpl6x9rhtMmP2Km1LOLGDK5fOam9Eu++MU+PTFIksAQzAyPKldghAAAIxTeDRt0vV91uZLFBj5dvnTXXauqeqVv7v48ulUWegzlefdk/pCUc7zXjBwBbDzYynW/+4THbpUql72lVtPsdgjGRnf6t7BE3Dyc2Pduz81wzeko/2hKuGPAgkPAH/f9IlfHfpIAQgAAEIeAmY8WfylrrJcMVOlNqhDDOUnvxgh2PkbT9wRCp8nk7MQLRDF67xZ+8FmdRzq4v6c2rAKdNgDbKZMJuZ8oq5QDl9UoE3qXUPol+iJ2JLubaHzcTckZjYrKG5KDEXIBN12RWBQCwQ8P9tj4UW0QYIQAACEEhoAnai9mefPL61j3aDxvNhrtUyFyVZ6nbk+8+udk7nui/arOMfPn+yc/2XOdd97sNd8syHLddtfeH0cepvbYCz181uXThDXYLsVsPVbnBwrwuzPXiu2M0XtsS873Cdc0uDPfNzM/TWjQz57Hx9T59VtfV6ijfbfSXo05bSH7juRMeAdm97sGXRh2+c69RvS6wIBGKBAAZgLIwCbYAABCDQQwTM2e17uoF+pu41s1OZdkWZXT1m10ydpLNc5ozW9ujZXrXagH10dkOFHQiwMsHk3d26r2/JNseQCZbf2TQzkkbprJgr3lOhblrg01yzmOHoFTsgYbN27sydO/NmZcygG56X01rcDjAYDxO3fGumL+Btl7d9rtEXuE8y8H03bleoBV6jZm3t4CYz93WeEOgVAhiAvYKZj0AAAhDoHQI/fnGN4+/OZp0e0Vmnrz3xYeup1Eff2Rq2EU8t2xE2f9m+Jtn8TtvdsWELh8n0GmpWzAzScGL++Uy896lafECfNnciFvfO6HnDlodAAAL+BDAA/XkQgwAEIBDXBMzZsYm7zNnVK8JspmyMzs553aaEA+K6WLFrv8yMs/emj+ivpzxHyl/VoLSrw7z3qJqtd/2CIr8qT9N9dit2VEhNXaPY1WA79Cowe+dgzVFnFm/UwJaZu0+dNMo5BWyuTMzp89Xz/E+rnjqxQMzPX65ePzZN24BAAAKhCWAAhmZDDgQgAIGkI3CKuiL55sIp4r2O69mvnOrsrfvZcy3uTQyKzbA9dcspYfnMGxfarYn3RVuq/cElM7xJQcPmfuSnnr2DgYVsqfb7lxwXmEwcAhAIQgADMAgUkiAAAQj0NIG9h2r1qrPNzjLmLXqxvPnGs/15tu9uRVmF+qVrcbEyVX3W2R48M4rsJK7NppnYoQQTM4JGaN4v/7nBiVv5UHL9794LlUU6BCCQ5AQwAJP8F4DuQwACvUPg9fX7nNsN7Gt2e4PdSVvy0e52V4u5S7h2nZbJ6xv2OU/3h5sfKu6m23P/YZ/fFm9iB+EheueuiRmW9i334EO+z7WJ+7qdkEUgAIH4JYABGL9jR8shAIE4IuD1mWe3bJjYTRrHKgt0ydb2w3ll0VulrVE78WoziSaTh/VzTvkW9M2UvYdaZhQXjC9QVykpYtd32dVgZ+t1XibfKJ6id+vuk+N9vuzsOxcVpUrDwALHl92cMaGv+nIq4AcEIBDTBGLRADQnS4+rTlO1fwLvVr1ZtVT1LVXXd4C1fbqqOZNaoeqVIo1sVG25e6cl53J9hHch31KOnxCAQBIRaNbbLuwKM1cs7oo33U1z8y3PDbt5gU9vmWZpq9dC9q7nU4Gvdjo+a3S+LDxuuF/5p5bvaL179qITRshj77ac3L1MD2YsmODv2Nh9MXC/3mCdCbz4hJFutqTrVXAzClKlWA1DBAIQiH8CsWgAGtX7VV9UtT8nv+yLn6vPBaquXKGB76kGGn9ufoUGTnAjPCEAAQgEElj8QZk8/PZWOUNPj9527mRnT96X/vBBa7H/vmqW2ClXV55Ww+qhN0ude28vn1Mof9VbMtzZNbeM99k/J12qjrTMvnnT71GHxggEIACBaBJoca4UzRa0/3atJr2g6v5z+R0Nj2tfTG7UtAeDpJMEAQhAoFMEfq9+8Zr0DrNX1pU75VeUVfq996G6FPHKG7ofz8rX6BVpj6rhGM74s/eCGX/e+roSnji0r3MzReA7owe2Gahunt16YWKuVCbpeyY2yel1buwk8gMCEEhaArE6A+gdkFs18qw3QcO2LvEx1c+qhhI7OrdE1VzHP6X6Q9VGVQQCEICAQ8A9edsbOBZMGCSXzy5Uv3iV8tAbpc4nz5k2VP6+ek/r5x+8/kS5+5mPdCbyiJP2LXXHYkuxZrwVDeojDU1NrXmWZgczhgS5muxzp46Vj+tBE7v5wm6k+N/Pnujs8xukV6IhEIAABIxA28aX2ORxhzbrQtWzVFuOxLW08zv6sL1/V7ZE2/20P+XyVPeqDlT9k+rfVX+iGii3aYKpI7m5uSMXL17sRnnGAYHa2lrJzs6Og5bSRJdAV8dsb02zVOiZhXH6X7V7a8TO6mbZeqhZcvSfeEf0n3Zj+qWogSRSebRZCvukSLnaUI26yW64hjdXNYv6GBY96yDqI1hqdFW2rx5ifWZL2yGMswtTZdWBZtmt33Jl+sAUGZ/X9sfkGzub5UBdW75brjPPE4fo/rnRqbKholme2Njyb9HTR6TKaztb2pCp6zHfmJ0uj65tlG2HW77x5RlpkpfV9v3OfCeSZbo6bpFsC3V3jgBj1jlOsVRq4cKFO7Q9hZFuU+z8ydK+p1/XpE+rnq3qXYexNm9QvUW1RLUzcpUWulrVjMmwUlBQ0Fxe3rIcFLYgmTFDoKSkRDemF8dMe2hIxwS6MmaVR+rlmgfedSq9et5ouWruaL0p4ojc/OjSjj8UQyUu1sMYN502Tt2+HNBZvpY9gNeePEbc69lsufaB605yZgCXbj3otPx3N5wkBTE0a9eVcYsh9EndFMYs/oZfD4/1igEYq0vANiNnRlug8WcjeYZqpqrN6IWSIZphf4LWq9ps4GWqy1QRCEAgzghU1th/xi1ijpNN9vucIrekdv/nIHWHEs5Xnt0sESh7qmolS5045+dmioXDiS3flqu7FfOl97HJ9seSujcYnuf4ALR9hKfo4ZPqow2ypPSAXDNvjJN/iZ7UNafPE4f0k0F6ny8CAQhAIBIEYtEAtGnPn6tuVn3F12ld/JF5vvDn9Pk71ba1m5aMe/SxU/W3qqeqWtzWWayPL6vaHkAEAhCAgEPAHB4/eP1JTvinJWvlNXXU7BW7/qwz8s7m/fLD59c4Re2OWzsdHE7MGPReV3bDKWPF1BVzEP3rq2e7UZ4QgAAEIkIgFg3AMu1puKXpa0OQ+K4n3TbxsZHPA4QgBGKBgDlDfvCNzfL79xvk8Z3vSaqeZHAdEg/Py3ZO19qS70R1SLxBr0MLFLsV4/UNbwQmE4cABCAAgS4SiEUDsItdoDgEIBAvBNbsqpJnP9zlNHdfwDVluyrbllODGX893Uevf79BfWynSJuMG9zetUpbrn/IbtpwpV92W9hN4wkBCEAgFgnwp1UsjgptgkCCEuiJq886QnOFLsGmpvoWEey2DX3B9e83d+xAGT0wV7btr5GPT23Zk2f1XXFioeSpS5Ua3Y+XoTdenObzo9fRtyx/2vD+cutZE6W2vlFO78J7nambMhCAAAQiRQADMFJkqRcCCUbA7q9t0CVcV7xhS+uje9tMqvVwQ5o5qVMxNyxeOaJ5kZbrdB9eR3LyuEF+RfpnZ3S4d8/vBU/EjE3z54dAAAIQiCcCGIDxNFq0FQJRInCw+qh8Ud2uHNFZrlBy/Kg89dGXqm5OWlyYhCpHOgQgAAEIRJ8ABmD0x4AWQCDmCWwsPxzW+LMOfLjd/xq13upU4YAcsX14a3cfkk/MHN5bn+U7EIAABOKaAAZgXA8fjYdAdAl8c+FkZ7n3Ry+uDdoQc9x86oQCJ8/cpTyi9+eanDw0Vb76yTlO+AuP+Dt0tuXUW86c0Opjr7/uzTuqV3yYkWf+8VwZpj76yjU+UH3ltZwmrhVLQyAAAQhAoGMCGIAdM6IEBOKagDlSfmfL/tY+ZOh9aEcbmiVN966ZYZVu96Op2BVrdRrfqgckRg3MkVzd03fkaJM06T6+p5aZY/r2YgaXeq1vn+FLGaDOkkfpoQuTDXsP+VJFBqidNjwvpzXuDdjNF9Y2u8e2VXyHdP3SNNPrqDlUfa11EIAABCAAgVYCGICtKAhAIDEJ/ObVjfLWxjYDsCd7aYZaOAPQvbfXvmmzdK74bE436vf0vuOXQQQCEIAABHqMAAZgj6GkIgjEJgE7wBEJOUvdqBQNavGXd/bUobJ5X4vjZq9PvZOKBrZ+es6YAWJuWGxGcUJKm5PnW84cL/e+sskpZwdJTtXr0RAIQAACEIgsAQzAyPKldggkFIFQ16P929kTO+xnP3W1ctcF05xyJSVlreUXHjdcTBEIQAACEOg9ApEwADO0+V9THaf6jOpzqq78SgNfcSM8IQCB0ATW7q6SF1bscnzv1dY3yaHaeuekq/vGaTpTVlTQR0r3VTuHI2zvnCsVep3ayrJKGaAHJCI1A+h+iycEIAABCMQfgUgYgGbk5asuUf2p6lmqX1U1OaXlwU8IQKAjAg+/tVVW7QjtWqXlXtx9nmraDlm4icdq/Nm2PdeX89D+bQamWz9PCEAAAhCITwKRMADnK4oTVO0KgN+qPu573qzPtl3gGkEgAIHQBOoaQjtdDvXWrNH5MiwvW15cubtdET2vIWN0z565Tdm6v1oWjC+QScP6OTOI5rx5uL6Xoyd/zd1KdV2jhlNl+og854q0d7cckI9NHtyuThIgAAEIQCA+CUTCALQlYPf+p2oNX6r6hOr/qiIQSCoCTXp1ms2iuSdlm33TafZwD8W6M2ztwLj/FbXLCJ1w5uQhMn/8oKAG4GfnFwW97uwMvb+2o+vTjhuZF/qj5EAAAhCAQNwRiIQBWK4UjlNd5aPRoM8rVf+kOtOXxgMCCU/grU375BcvrZfRg3Llp1ccrz72GuWrf1ouOytqnb5npadKRlqqHK6z/0QQCEAAAhCAQO8RSI3Ap27ROlv+hmur3DUCr21LIgSBxCbwytq9jmPlDXsOy+6qWtm0t7rV+LOem9Plzhh/XmfHHREzp8uZalQGe6eooMUhc0d1kA8BCEAAAolPIBIzgN9RbFcFQWcbmh4Lkk4SBBKSgK7+dkkuPmGEnDaxZZ/dh9sr5NF3tjrvX3j8cJk1aoDU+vYEfu2JD1vr/dknj5fB/bKcU8C2t889Cfzrq2epsXlE+uh+vko9EdxfXbDY3kAEAhCAAAQgYAQiYQBOBi0Eko1AQ2OT2EGKbQdqHCPM7qx9Tw9OuPLOpv1SczT8Uu8QvVZtsh7KMCk/1HbnrcVtGTmYuOXN+PNKdkaajBvc10kKNhvoLUsYAhCAAASSj0AkDMDko0iPk57A3z7aLfe9ujkkh0VvlYbMczPslK4r/mFPhhbIy8lwZvXcsjwhAAEIQAACXSUQCQNwhjZib5CG2N9itig2JEgeSRCIawKBM3bBOpOuF+A2NAZfF56iM39zPdemzSjMk5mqR3WfoF2f5pXPnz5OHn9vm5wygSvTvFwIQwACEIBA5wlEwgBcr58/v/NNaFfSNio9rjpNtUbVHJrdrFqq+i/V0apVqiYPq/6XE2r/43OadLuqHXT5p+qXVMOvwWkBBAKRIjBWb+34xZXmIlPk0bdL5Yn3y5zwxCF95ae6l88rdm3aDy+1f0u1F3PbYopAAAIQgAAEuksgEgagbV7a2t0G+d67X58vqtp0yZdVLX6uqsmtqt7r5ZzEgB9jNf591VmqNhv5tKoZhPepIhBoR+DI0UZ58I3NYgc3MtU9S5UenPjMyWNkZH6OU9auZXtyaZnUe2bwdlUecU7bpqpDv7KD9m8VBAIQgAAEIBAfBCJhANpS77GIuZB5wVPBOxr+v554Z4JXaKG/qu7xFf6tPr+pigHoA8LDn8D7Ww9IyUfur0tLXn/da3fzGeOdyJ91ts57qMN92/Xp58bDPe0krit9s9v+0+vnCbv5PCEAAQhAAAKRJND2t1DPfcVm3XpSbMbvWU+Fdr/wj1RXq35bNdjOe1sm9s5Clmrc0hAIBCVQr6d4A6W2vu0qNjd/+oj+Ml1vxXhm+Q6prW95Z86YATJel3FL91XLoL6ZMm/sIHln836xe3jPnjZU9qgPwBqdYfRepbZw+nCxmUNLZzk3kDxxCEAAAhCINIFjna2LdPvu0A9cqHqWqq2xjVLdrmrtNofTtq/P9goGyq80YZuqGYsm01XNiBxnkQC5TeOmjuTm5o5cvHixG+UZBwRqa2slOzv7mFq6cl+TPFPqbwTOHJQqF45t8ZX+x/WNsrmqWU4bkSqnq/5yeaMcbmg50LFwdKrMGdJS7pgakUQv98SYJRGumOkq4xYzQ9HphjBmnUYVMwUXLly4QxtTGOkGxbIB+HXt/KdVz1atCAHClotHqu4PyP+GxotUzUg0OV/VloA/phpWCgoKmsvLy8OWITO2CJSUlEhxcbHY1Wv/869NMnFIP7nrgqlSrbNr3/rLCsc3X0ctDnVCN0f96ZnYNW62P/CquaPl6nmj5doH35WKmnonz5aJPzFzuBPmR+cIuGPWudKUihUCjFusjETn28GYdZ5VrJTUu+N7xQCM1WkLm5G7SvUcVdf4s+XqoaquXK4B27QVaPxZ/pOql6paeTNy7RTx46pIAhN4fsUuxyhbUnpA9uvy6zo9uGGOmTsjodyzHNFlYFP3Vo8R+S0zjYUDWg6HWN0jPeHOfIsyEIAABCAAgWgTiMQewGPtk017/lx1s+orvsrq9FlZxhkAAC7ySURBVPlx1edVs1RtrW6f6kWqrjyggWd8au9+T/VNVTNyX1Z9UBVJYALuPj23i80tK7RuNOzT9u59+cwJThndmie2JdBmBb1ihzjGD+7jJH3vwumydvchGZCbIWMGtaR5yxKGAAQgAAEIxDKBWDQAyxSY/9+8bQRPbAu2C90UkPK/GjdFEozADr3jduv+aqnzHcJYX9Es+XroYs2uQ609XbatQpZtO9ga7ygwMDdTTvQ4Yu6ovF21dsKo/I6KkQ8BCEAAAhCISQKxaADGJCgaFRsEDujS7s2PLvVrTGVVo7y0d41f2n//c4NfvKNIVkas7oboqOXkQwACEIAABLpOgL/1us6MN6JIYN9h2w3QXnIzWw5rtM8JnnL9giK/GbxLThgZvCCpEIAABCAAgQQkwAxgAg5qsnUpW22/H1xynNz2xIdO18+bMUxeXLm7FcOzXzm1NewNXD4n4qfsvZ8jDAEIQAACEIgZAhiAMTMUNMQl8OH2Cvn76j2yVU/w7tT9flOG9ZMVZZVy2sQCqaqtd4vxhAAEIAABCECgmwQwALsJjtciR+CBN7Y4t2q4XzDjz+T1DXbwu70MyUmR3Ky2X+V+Gs7QE7x2b+/Q/nZoHIEABCAAAQhAwEug7W9NbyphCESRQJ3nCrbAZlx4fIvDZbuGbVP5YRmZnyOFdS3Pr3x8guw9VCcXzhwhs/V6tnc2H/C7fi2wLuIQgAAEIACBZCWAAZisI9+L/W5SL8rmW0+9m0uzOucz/3wWN3HDXp99odz39dWZvS+cPr7lRc/PkpKtTuzc6cNaU/Ny82T6iLzWOAEIQAACEIAABNoIYAC2sSAUAQK//McG+ceaPWKOln982Uz52Uvr9IaONn99EfgkVUIAAhCAAAQg0AEB3MB0AIjsYyPw+oaWe5X3Hz4q/1q395iMv49PGXJsjeFtCEAAAhCAAAQcAswA8ovQawRCLe26DThj0mC58PgRTnRgn0zJTE+VQ3rqt6BvlnMaeGwBV665rHhCAAIQgAAEjoUABuCx0Evyd80p86HaBhncL8s5tZuqG/vGD+kjm8ur9S7dFnOvybO5b29VcCfOLsYBavRNVpcvXsnLyXCi4wb39SYThgAEIAABCEDgGAhgAB4DvGR+1Yy/zy1aIj47r1MobC9gOAl1AXS4d8iDAAQgAAEIQKDrBDAAu86MN5TA7srasMZfqu/Ur8FyZwPTLNETt7D56as8Ui/ZGWkyd+xAS0IgAAEIQAACEIgwAQzACANO1upvPHWsXMz9usk6/PQbAhCAAARinAAGYIwPUDSaV1lTL39dVia7dJavv+7Bq65rcGbo3Bk8a9OB6qPRaBrfhAAEIAABCECgBwhgAPYAxESromT1bnnygx3H1K2s9LRjep+XIQABCEAAAhCIHAEMwMixjduaa0NcxTZmUK5MGNJ2Grfs4BE/v37zdA9f3+x0yddZw9MmFsRt/2k4BCAAAQhAINEJYAAm+gj3YP/MwLt2fpFfjf/5t7XyxoZ9TtpnNW+0GokIBCAAAQhAAAKxTQADMLbH55haZ6dv73xqpazaUdVhPXY3r8dlX4flKQABCEAAAhCAQPwSiMWr4LIV51Oq61WXq/5NtUjV5CHVdaqW/prqCarBpEgTG1StnKvjNZxUUnawplPGn0HpjPE3Ij+nHb8JPgfN6WkpMlDv+0UgAAEIQAACEIh9ArE6A3i/ontR1a6T+LKqxc9VfUr1C6pm3F2g+oTqJNVgUqGJJwTLSJa0zhh14VjcdNpYOb4w37ntIyczVcYHuY3j0lkjZfrI/s51bX2zYvXXKVwvyYMABCAAAQgkH4FY/Bu7VofhBc9QvKPh/+uLPxOQPkbjNovZ5ElPqGCzWnHr9hySHHWUnKL/qz7a4Bhbq3dVSZMu8WakpUp9Y5PkZFq+v2wsP+yf0MXYnDEDpHBA+D19qercecqw/l2smeIQgAAEIAABCESTQCwagIE8btWEZwMTNf5vqmYohjL+zCpZomr+SGzm8IeqjapxJW9u3C920CIakmIbAxEIQAACEIAABBKOQKz/DX+HEr9Q9SzVGg/9azR8l+ppqns96W4wSwN5vjy7X+xPqn9X/YlqoNymCaaO5Obmjly8eLEbjfrz7V1N8vKOUDauf/Ny09uG0w6A1Hlem5iXIiP6pMjS8mbpnyFyuF4tY507zVLzuFrD84elyOoDzVJWbavuIlb+igmpkhoHRmBtba1kZ9vWUSReCDBm8TJS/u1k3Px5xEOMMYuHUfJv48KFC80Rb6F/as/H2iyGnq/7WGv8ulbwadWzVW0/nyuf0sAPVM0o3OYmdvC8SvOvVjVjMqwUFBQ0l5eXhy3Tm5l/WVomD79V2qlPPvuVU1vLLd9eIXc9tcqJf3ruKPnMPFstT0wpKSmR4uLixOxcgvaKMYvPgWXc4m/cGLP4GzNdfesVAzBWl4BtRs6MtkDj70pNM+PP0sMZf0M0/6Cqzm2JzQZeprpMtUM52tgs//X39fKJmcPl7U37ZU9VrZw8bpCcPmlwyHff2bxf3tq4T86dPkyOG2kTjyJ2ndofl2xzrlEr1nTbs/fo21udvNEDc/WKtRb0VUcaZNuBlsnNKcP6yeB+1lxxrmAzh8p/eDdcN52i/IAABCAAAQhAAAJdItBihXTplYgXtmnPn6tuVn3F97U6fc5T/YPqbtWnVV2xmcD9qveo7lT9rapNhVnc9vxZH19W/aFqh1Krb7y8dq+jbuH3thwIawD+8Pk1TtHlZZXyyI1znfC/1u+V51fscsJmSNY1tK3HugafW7/7XLv7kJh2RwJXavvooRBXOJ3rkuAJAQhAAAIQgIARiEUDsEzbFWppOiPMsH3Xk2eb+HpsI5/XePN8o13wYPXR1rS6+jaDr7Pvt74cImCncpdutYnNNjl76lDpoxv5bJbSK3Zl2xfPGCeHaxvkLC2DQAACEIAABCAAAZdALBqAbtt4egiYo+W7L5ru3Ozx4fZKJ+eB606Uof2DH36wE7wXzBzhqYEgBCAAAQhAAAIQaCGAAdjJ34QLf/WGU3Jgn0znaWdlvTN+bjXXPfSeEzzgmQ1083hCAAIQgAAEIACBWCCQGguNiKc2mGFnGsz4s364+cfSp4lD+7Z7fb5vide9ei1NHTD3zw63It6uChIgAAEIQAACEICAQ4AZwIBfBDuce8uZ4+XeVza15swanS/LtrV4oikq6COfPmmU/PbVTVKhJ31NrLxdu9ZfT+2aPL9yl6zUAyGh5Ep9/4kl21uz7X2TbL3tY5SeEB6pd+5+qG5cGtSX34DcTL2KrV6OH5XvlPnMyWNkRmGe2L28dvsHAgEIQAACEIAABLpKAAMwgFiGzqwtPG64nwE4LK9tn525ZjllQoGYfz7XAJw7dpC4S8NW3bJtB8MagOcdN8zPALTvBcq8gEMdbr5d/TZnzEA3yhMCEIAABCAAAQh0mQBLwF1E5rpbSVdD0ZW2UEsKV6i5ZHhCAAIQgAAEIBCLBDAAQ4zKVXNH65Jsqlw2e6TjYsUcN+foEu1pE1scQl94/AjH/Yq5ZsnP9d+LZzOEeTpTaDqob6ZzUveGU4qc8rN1OXmQHiS5Vpdyrf6LT+CkboghIBkCEIAABCAAgQgRYAk4BNir540WU1f+cNPJbtB52s0goW4HOUH36/3+JvNb7S+XzW672s/2AZoiEIAABCAAAQhAoLcJMAPY28T5HgQgAAEIQAACEIgyAQzAKA8An4cABCAAAQhAAAK9TQADsLeJ8z0IQAACEIAABCAQZQKJsAcwSxn+XLVY1S7jXaZ6jepE1YdVC1TNid/1qqtVw0pFRYUUFrbt1QtbmMyYIFBXVydZWfZrgMQLAcYsXkbKv52Mmz+PeIgxZvEwSu3aOLJdSgQSEsEA/LFyaVKdpGo3tLlO9e7T8P2qi1SvUH1Qdb5qWMnPz5eysrKwZciMLQIlJSVSXGz2PxIvBBizeBkp/3Yybv484iHGmMXDKPm3UV3JNfqnRCYW7wZgH8Vyg6pN2ZnxZ7JLdYjqbNVzVU2eVP21apFqqSoCAQhAAAIQgAAEkpZAvBuAdofaftU7Vc9WPaJ6t6ot+e5UbVA1MeNwm6r5dSlVRSAAgSgRaNZ7E1/b2STvPdfhjowotZDPhiJQWtoo79UzbqH4xGI6YxaLoxIbbYp3A9A8MI9TtT+Rblc9XvUfqheoujOCGnQk8MION/02DZg6UlNTIzZljsQPgdraWsYsfoZLDtSqAVjWKCk7t8RRq2mqEWjW+8k3VDJu8fTbwJjF02i1tvVwayiCgVBGUQQ/2aNV2wGPPaqZqu6a+Xsa/pnq/6oOUrVZQOunLQ2bN+dS1ZBSUFDQXF5eHjKfjNgjwB6X2BuTcC3aXH5Yrr//VcnrnyeXzBop3msVw71HXvQJrFmzRqZOnRr9htCCThNgzDqNKmYKXn/K2B3amMJINyjeZwD3KaB/qharvqA6RnWs6uuq7mngRRq+XLXUp/pAIACBWCDwGb1tJ1uvWETig0DJoXVSvKAoPhpLKx0CjFn8/SJc30tNjncD0DDdrPqQ6n+q2izgF1Rttu+LqotU71CtUr1OFYEABCAAAQhAAAJJTyARDMDNOoofCzKS6zStQ7cvQd4jCQIQgAAEIAABCCQ0AW4CSejhpXMQgAAEIAABCECgPQEMwPZMSIEABCAAAQhAAAIJTQADMKGHl85BAAIQgAAEIACB9gQwANszIQUCEIAABCAAAQgkNAEMwIQeXjoHAQhAAAIQgAAE2hPAAGzPhBQIQAACEIAABCCQ0AQwABN6eOkcBCAAAQhAAAIQaE8AA7A9E1IgAAEIQAACEIBAQhPAAEzo4aVzEIAABCAAAQhAoD0BDMD2TEiBAAQgAAEIQAACCU0gEa6C69EBqqlvlq//+cMerZPKIktgx45G+XsVYxZZyj1Xe229XdmNQAACEIBANAlgAAbQb2gWWbf7UEAq0VgmUFndLIcZs1geoqBt65OVJhlpLEIEhUMiBCAAgQgTwAAMAnjCkL5yxqTBQXJIikUCK1askJkzx8Zi02hTCAI2ZlefN0PSUlNClCAZAhCAAAQiSQADMAjdUQNz5ZJZI4PkkBSLBHL2rpJixisWhyZkm2zM7B9aCAQgAAEIRIcA6y/R4c5XIQABCEAAAhCAQNQIYABGDT0fhgAEIAABCEAAAtEhgAEYHe58FQIQgAAEIAABCESNAAZg1NDzYQhAAAIQgAAEIBAdAhiA0eHOVyEAAQhAAAIQgEDUCGAARg09H4YABCAAAQhAAALRIYABGB3ufBUCEIAABCAAAQhEjQAGYNTQ82EIQAACEIAABCAQHQIYgNHhzlchAAEIQAACEIBA1AgkkgH4PaWoN/nKcT6aE/X5lup61fdUp6kiEIAABCAAAQhAIOkJJIoBOFtH8mTVbZ4RvU/D96tOUv2J6oOqCAQgAAEIQAACEEh6AolgAGbpKN6r+iVVmwE0GaJqRuHvLaLypOpY1SJVBAIQgAAEIAABCCQ1gUQwAO/RETRDb4tnJEdpeKdqgy/NDEObHRzti/OAAAQgAAEIQAACSUsgPc57Pl/bf5Lq7UH64c4GulkpbiDgeZvGTR1pamqSTZs2SkmT1550c3nGIoHa2lopKSmJxabRphAEGLMQYGI8mXGL8QEK0jzGLAgUkhwC8W4AnqG9mKLqWmuFGjZL4A5VC1v/bBbQjD+bFbRZwED5hSaYOpKamto8fvwEKT7Htg4i8UDAjL/i4uJ4aCpt9BFgzOLzV4Fxi79xY8zib8x6q8XxvgT8YwU1QrXIp2X6NEvgYdVlqteomlyuWupTfSAQgAAEIAABCEAgeQnE+wxguJH7omYuUrXZwCrV61QRCEAAAhCAAAQgkPQEEs0ALPKM6DoN2x5BBAIQgAAEIAABCEDAQyDel4A9XSEIAQhAAAIQgAAEINAZAhiAnaFEGQhAAAIQgAAEIJBABDAAE2gw6QoEIAABCEAAAhDoDAEMwM5QogwEIAABCEAAAhBIIAIYgAk0mHQFAhCAAAQgAAEIdIYABmBnKFEGAhCAAAQgAAEIJBCBWDYAzZkzAgEIQAACEIAABCDQwwRi2QA8s4f7SnUQgAAEIAABCEAAAkog2o6g94YYhRRNzw+RRzIEIAABCEAAAhCAwDEQiLYBaIbeWaqVAX2w9DcD0ohCAAIQgAAEIAABCPQAgWgbgEu1D4NUVwTpy+4gaSRBAAIQgAAEIAABCBwjgWgbgJdr+4/6+jBYn0dUD/vic3xPHhCAAAQgAAEIQAACPUgg2odAqrUvn1fdqbpH1ZaCbTbwbFUT9gG2cOAnBCAAAQhAAAIQ6DEC0TYAzfj7surnVAeq2nLw7ao/Vz1X9Z+qCAQgAAEIQAACEIBADxKI9hLwrdqXharbPH16QcOrVder/sKTThACEIAABCAAAQhAoAcIRHsG0L7vNf7cLpVqwNRmAxEIQAACEIAABCAAgR4kEG0DMFP7kh2kPzmaFu22BWkWSRCAAAQgAAEIQCD+CUTbyFqsCB9V9R72GKDxR1SfVEUgAAEIQAACEIAABHqYQLQNwDu1P/WqZarLVD9Q3a7aoGp5CAQgAAEIQAACEIBADxOI9iEQM/6uVh2vOtvXNzMEN/rCPCAAAQhAAAIQgAAEephAtA1AtzubNGCKQAACEIAABCAAAQhEmEC0l4Aj3D2qhwAEIAABCEAAAhAIJIABGEiEOAQgAAEIQAACEEhwAvFuAJoLmadUzWn0ctW/qRapmgxRtfgG1VWqp6oiEIAABCAAAQhAIOkJxLsBaAN4v+pk1RNUn/PF9SE/Vn1HdaLqDap/UI2VPY/aFAQCEIAABCAAAQhEh0C8G4C1is2ujmv24TODb5wvfKU+7/WFl+hzjyqzgD4gPCAAAQhAAAIQSF4C8W4ABo6c3S38rOogVetbuaorpRoY7UZ4QgACEIAABCAAgWQlkEhLonfoINpy782qdpWcOyuoQUdS3EDA8zaNmzrS1NQkmzZtlJKmLW4SzxgnUFtbKyUlJTHeSprnJcCYeWnET5hxi5+xclvKmLkkeAYSSBQD8OvasctUz1at8ak+ZLCqOws4RsPbLDFAfqFxU0dSU1Obx4+fIMXnTHKTeMY4ATP+iouLY7yVNM9LgDHz0oifMOMWP2PltpQxc0nwDCSQCEvANnt3leo5qhWeDv5Zw7f44ifpc5jqG744DwhAAAIQgAAEIJC0BOJ9BrBQR+7nqptVX/GNYp0+56l+S/VRVXMDc1T1WtUGVQQCEIAABCAAAQgkNYF4NwDLdPRC7e2zU7/nJvXo0nkIQAACEIAABCAQhEAiLAEH6RZJEIAABCAAAQhAAAKhCGAAhiJDOgQgAAEIQAACEEhQAhiACTqwdAsCEIAABCAAAQiEIoABGIoM6RCAAAQgAAEIQCBBCWAAJujA0i0IQAACEIAABCAQigAGYCgypEMAAhCAAAQgAIEEJYABmKADS7cgAAEIQAACEIBAKAIYgKHIkA4BCEAAAhCAAAQSlAAGYIIOLN2CAAQgAAEIQAACoQhgAIYiQzoEIAABCEAAAhBIUAIYgAk6sHQLAhCAAAQgAAEIhCKAARiKDOkQgAAEIAABCEAgQQlgACbowNItCEAAAhCAAAQgEIoABmAoMqRDAAIQgAAEIACBBCWAAZigA0u3IAABCEAAAhCAQCgCGIChyJAOAQhAAAIQgAAEEpQABmCCDizdggAEIAABCEAAAqEIYACGIkM6BCAAAQhAAAIQSFACGIAJOrB0CwIQgAAEIAABCIQigAEYigzpEIAABCAAAQhAIEEJYAAm6MDSLQhAAAIQgAAEIBCKAAZgKDKkQwACEIAABCAAgQQlgAGYoANLtyAAAQhAAAIQgEAoAoluAE7Ujr+lul71PdVpqggEIAABCEAAAhBIagKJbgDep6N7v+ok1Z+oPqiKQAACEIAABCAAgaQmkMgG4BAd2dmqv/eN8JP6HKta5IvzgAAEIAABCEAAAklJIJENwFE6ojtVG3wj26zPbaqjfXEeEIAABCAAAQhAICkJpCd4r83o80qKN+IL36ZPU0eampokZd8mKSnZ4ibxjHECtbW1Ol4lMd5KmuclwJh5acRPmHGLn7FyW8qYuSR4BhIIZhAFlonXuC0Bb1AdpGqzgNbXXaonq5aqBpVBgwY179u3L2geibFJwIy/4uLi2GwcrQpKgDELiiXmExm3mB+idg1kzNohifmElJSUHdrIwkg3NJGXgPcqvGWq1/ggXq7PUp/6kto/FHz7RFIgAAEIQAACEIBAAhFI9CXgL+pYLVK9Q7VK9TpVBAIQgAAEIAABCCQ1gUQ3ANfp6M5P6hGm8xCAAAQgAAEIQCCAQKwagObA+WHVAtUK1etVV6sGyp2acIMv8TF93uULX6/P/6daqmpyUPVMJ9TBj4qKCiksjPjSewetILsrBOrq6iQrK6srr1A2ygQYsygPQDc/z7h1E1wUX2PMogi/+58e2f1XO/9mrBqArgPnRdqVK1TNgXPgTN7pmnaV6kzVBtU3Vd9QLVE1+Yeqvdslyc/Pl7Kysi69Q+HoEmCTc3T5d+frjFl3qEX/HcYt+mPQ1RYwZl0lFv3yehahsTdaEYuHQDrrwPlTCmiRarVqnepDqmYQIhCAAAQgAAEIQAACYQjEogHYWQfO5tB5q6dvpRr2Onk+Q+PLVW1msMszgfoOAgEIQAACEIAABBKSQKwuAXfGgbMNiLdcimeEntPwE6o1qlNVX1K1dd13VAPFzxF0TU0NToUDCcV4HEenMT5AQZrHmAWBEgdJjFscDFJAExmzACDxET3cG82MRQNwu3bcTmFY22xvnxl2Nito17h5xeJFnoQxGnbLeD05r9H0F1RPUQ1mAP5C000dyc3NbcapsEsjPp7scYmPcfK2kjHz0oifMOMWP2PltpQxc0nE1bNXDMBYXALurAPnP+twXqfaR9WOgN6o+riqifcEzVCNf1zVnEIjEIAABCAAAQhAIOkJxOIMoA1KKAfONpP3XdX3Vf+lasu8K1VNzPj7mxMSuUWfF6vWq5qR+1+qL6siEIAABCAAAQhAIOkJxKoBuE5HZn6Q0Tk/IO0ejZsGit38YYpAAAIQgAAEIAABCAQQsNkxBAIQgAAEIAABCEAgiQhgACbRYNNVCEAAAhCAAAQgYAQwAPk9gAAEIAABCEAAAklGAAMwyQac7kIAAhCAAAQgAAEMQH4HIAABCEAAAhCAQJIRwABMsgGnuxCAAAQgAAEIQAADkN8BCEAAAhCAAAQgkGQEMACTbMDpLgQgAAEIQAACEMAA5HcAAhCAAAQgAAEIJBkBDMAkG3C6CwEIQAACEIAABDAA+R2AAAQgAAEIQAACSUYAAzDJBpzuQgACEIAABCAAAQxAfgcgAAEIQAACEIBAkhHAAEyyAae7EIAABCAAAQhAAAOQ3wEIQAACEIAABCCQZAQwAJNswOkuBCAAAQhAAAIQwADkdwACEIAABCAAAQgkGQEMwCQbcLoLAQhAAAIQgAAEMAD5HYAABCAAAQhAAAJJRgADMMkGnO5CAAIQgAAEIAABDEB+ByAAAQhAAAIQgECSEcAATLIBp7sQgAAEIAABCEAAA5DfAQhAAAIQgAAEIJBkBDAAk2zA6S4EIAABCEAAAhDAAOR3AAIQgAAEIAABCCQZAQzAJBtwugsBCEAAAhCAAAQwAPkdgAAEIAABCEAAAklGAAMwyQac7kIAAhCAAAQgAAEMQH4HIAABCEAAAhCAQJIRwABMsgGnuxCAAAQgAAEIQAADkN8BCEAAAhCAAAQgkGQEMACTbMDpLgQgAAEIQAACEMAA5HcAAhCAAAQgAAEIJBkBDMAkG3C6CwEIQAACEIAABDAA+R2AAAQgAAEIQAACSUYAAzDJBpzuQgACEIAABCAAAQxAfgcgAAEIQAACEIBAkhHAAEyyAae7EIAABCAAAQhAoDsGYIZiu131ftULAhD+KiBOFAIQgAAEIAABCEAgxgh0xwA0I+8E1XWqP1X9L1VXTnEDx/icqO+/pbpe9T3VaarB5E5N3OTT7wcUCJcXUJQoBCAAAQhAAAIQSB4C3TEA5yueq1R/rnqi6gTV36qapLQ8jvnnfVqDzTBOUv2J6oOqgXK6Jlg7ZqqagXiearGqSbi8lhL8hAAEIAABCEAAAklKoDsGoC0BN/t4VevzUtUhqv/rSzvWh9U1W/X3voqe1OdY1SJf3H18SgOLVK0NdaoPqZpBaBIur6UEPyEAAQhAAAIQgECSEkjvRr/L9Z3jVFf53m3Q55Wqf1K12bhjlVFawU5Vq9fEjM1tqqNVS1VdsfirbkSfpapX+OLh8nxFgj8O1zfLTQ8vCZ5JakwS2Lu3Uf68mzGLycEJ0SjGLASYGE9m3GJ8gII0jzELAoUkh0B3DMBb9M0jPn6DfeHD+jQj0GbeekLcGUa3rlBLy95ygWXC5bn12vM2nzppDY1Nsr5srxPmR3wQaG5qlgrGLD4Gy9dKxiyuhqu1sYxbK4q4CTBmcTNUvd7Q7hiANvNnRuB3VIepmqH1kaoZUo+p5qtWqHZXtuuLharWNpsFNMPOZgVtFtArFi/yJIzRsFsmXJ7nFSf4C/1p6kifjNTmf7/iJDfKMw4IfLB0qcyeMycOWkoTXQKMmUsivp6MW3yNl7WWMYu/Mfv4nb3T5u4YgJ/XppkB+DnVt33NXKBPOxTyDdUfqR7L38Y2/bZM9RrVRaqXq5b6VB+t8mcN/Vr1N6pmKN6o6mILl6fFQktGWoqcOdm2ISLxQuBoaSpjFi+D5WsnYxZnA8a4xeeAaav5by1uhy7iDe+OAXirtmqhqjvbZo18QXW16gZVMwSPVb6oFSxSvUO1SvU6VRP7zndV31f9l+oTqitVTR5X/ZsTCp/nK8IDAhCAAAQgAAEIJCeB7hiAqYrKa/y55Eo1sEXVnEQfq6zTCuYHqeT8gLR7NG4aTMLlBStPGgQgAAEIQAACEEgKAqnd6GWmvpMd5L0cTetOfUGqIgkCEIAABCAAAQhAIFIEumOwLdbGPKpqhz1cGaCBR1TNZx8CAQhAAAIQgAAEIBDDBLpjANpBi3rVMlU7rPGBqp3ctYMY7iEMDSIQgAAEIAABCEAAArFIoDt7AM34u1p1vKrd2GFihuBGJ8QPCEAAAhCAAAQgAIGYJtAdA9Dt0CYNmCIQgAAEIAABCEAAAnFEoDtLwHHUPZoKAQhAAAIQgAAEIBBIAAMwkAhxCEAAAhCAAAQgkOAEMAATfIDpHgQgAAEIQAACEAgkgAEYSIQ4BCAAAQhAAAIQSHACGIAJPsB0DwIQgAAEIAABCAQSwAAMJEIcAhCAAAQgAAEIJDgBDMAEH2C6BwEIQAACEIAABAIJYAAGEiEOAQhAAAIQgAAEEpwABmCCDzDdgwAEIAABCEAAAoEEMAADiRCHAAQgAAEIQAACCU4AAzDBB5juQQACEIAABCAAgUACGICBRIhDAAIQgAAEIACBBCeAAZjgA0z3IAABCEAAAhCAQCABDMBAIsQhAAEIQAACEIBAghPAAEzwAaZ7EIAABCAAAQhAIJAABmAgEeIQgAAEIAABCEAgwQlgACb4ANM9CEAAAhCAAAQgEEgAAzCQCHEIQAACEIAABCCQ4AQwABN8gOkeBCAAAQhAAAIQCCSAARhIhDgEIAABCEAAAhBIcAIYgAk+wHQPAhCAAAQgAAEIBBLAAAwkQhwCEIAABCAAAQgkOAEMwAQfYLoHAQhAAAIQgAAEAglgAAYSIQ4BCEAAAhCAAAQSnAAGYIIPMN2DAAQgAAEIQAACgQQwAAOJEIcABCAAAQhAAAIJTgADMMEHmO5BAAIQgAAEIACBQAIYgIFEiEMAAhCAAAQgAIEEJ4ABmOADTPcgAAEIQAACEIBAIAEMwEAixCEAAQhAAAIQgECCE8AATPABpnsQgAAEIAABCEAgkAAGYCAR4hCAAAQgAAEIQCDBCWAAJvgA0z0IQAACEIAABCAQSAADMJAIcQhAAAIQgAAEIJDgBGLRAMxV5n9U3ai6XvUy1VBygWasVf3/7Z0LjB1VHcbX0FqoLVK0+KC2F6lRUQg1rfGBUsS4UQmPhofFYDfRoMGGCFQDQuyGl4kmEo1U46MpoWp5ipigNUpvxPAspcXik9rbCj6KkAKlLkmxft/ec8zJZO6pd7N379y9v3/yzXnOOWd+/8707Jm5M657mzRDstWkfdLmREcrjkEAAhCAAAQgAIG+J1DFCeAKeeVFab40KK2SZklF82Tv+9Lpkuv+XbpcirZbkeMTbYsFhBCAAAQgAAEIQKCfCVRxAniOHHJ9cMp2hb+WTgvpNPiwEhslrwDaPFFcOhpjAwEIQAACEIAABCDQkkAVJ4BzNdodyYgbijuvaGX1jlSleEyHKv6QtEn6knSQhEEAAhCAAAQgAIG+JzClCwTuUZ9vbdHvgpC/Pyl/WRIvRtN6aZlvB8+RdkmHSzdJl0hfkYp2sTKsUdu7d+/A+vXrY5KwBwiMjIzgsx7wUzpEfJbS6J04fusdX8WR4rNIgrBIoBsTwPcVB1FI71S6Jj0V8ucpvCvE08D1PpBk1BR/UvqP5GcIPfmzPSOtls6VyiaAX1O+NWrTp0/fPzjoRw+xXiHgCTs+6xVvNceJz3rLX3G0+C2S6J0Qn/WOryZ6pPF26UT3m+vvFhV+NlQ4SuGJ0p0hnQY/V2KR9JaQeYHCdSF+hMKpIT5N4RLpkZAmgAAEIAABCEAAAn1NoIoTwK/KI4dIfrWL78V6MuhVPNuV0mdGYwMDzyv8lHSH5Lp+/u9ayXaC5AnfFmmT9A/pGgmDAAQgAAEIQAACfU+gG7eADwT9BVXwL4HLzD/mSM0rg2Wrg7cr38IgAAEIQAACEIAABAoEcj+wKFTtm+Q+HalXDLHeIeB3Qu7pneEyUhHAZ735zwC/9Z7f8Fnv+ey1GnIVF+h6j2SbI36izfpU7z4BfNZ9H7Q7AnzWLrFq1Mdv1fBDO6PAZ+3QqkbdCfFZFZ8BrAZ+RgEBCEAAAhCAAAQmKQEmgJPUsRwWBCAAAQhAAAIQaEWAr2OUk7mvPJvcChPAZxV2Touh4bMWYCqejd8q7qCS4eGzEigVz8JnFXcQw4MABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgUoSeJNGda/0J+lB6RgJ6y6Bg9W9v/Rin2yW/Pm/mmTz5/6c/rO0VfLXX6LlymIdws4TWKku9ktvD13lzrFcWedHSg8mME36puRz6jFprWTL+SZX1tybbScJDKrxhyV/+crXwWWSLXcNzJU192Y7ngS+ocYaUnotdPu5c2esZW4XGwOBu7XPUNjvTIU8gBlgdDHwBPAjUnxh+XLFfxHGs1rhcIj7m9A7pCkhnSsLVQg6TOAdav9nkv0SJ4C5cyxX1uGh0nwgcJ1C/2cVz7fXhfycb3JlYXeCDhGwn56Wjgvt1xSOSDOl1dKwZOP62OTQre371fEcqSHFa6GiA7lzZ6xlbhdrk4D/ItotxQmETyx/DaQmYdUhsFBDeTwMZ4/C2cnQvGq7OKRzZckuRDtEYJra9R9QR0kNyRe93DmWK9Ou2AQQeIX68DVwRqGvnG9yZYVmSHaAQJwAeoJh80TwSenlUu4amCvTrliHCDTUbpwA5s6dsZa1Pew44Wl7x0m2wxt0PH+T/Bk4m5dqd0pzpYaEVYPAhRrGT6VXSX6H5VNStIYi9leuLNYl7CyBK9X8Wml70k3uHHtB9Tj/ElhdiB6tPr2adIX0Qenf0rDkSWEr3+A3wemi+f+psyV/996+mCUtkbwCyPVRECpsY70ejus5538kWJOAT6bU/NcVVh0CX9RQ/FzE5WFIOX/lyqpzRJNzJO/WYS2SVpUcXs4vubKSpsgaZwJT1d4bpd9JC6Xl0jrJiwQ53+TKtCvWQQL2zWXSadI86WTpBsmW80uurLk324kgkPPDWMsmYtyTrg8vuT4r+YSyefLHLeBRFJXYrNAoNkqHJaPxX0Kzk3R6CzhXluxCtAMELlWbXjFqBHlV3bellkmtzjHOP8Hpsr1a/b8kpR8H8Dl1toTfBKGC5om6J+ypPaTESVLuGpgrS9siPr4EGmouvQU8lvOKa+X4+uR/rdUVGwqpMxXeH+IE3SVwsbp/WJpVGMYapYdD3iKFO6U4gV+j+LBkK5Y1c9lOFIGGOooXvbriQ5KteI7VlTck2YplzVy2nSbgH1j5R1e2eZIfsfAPQerSkGQr+qauvCHJVixr5rLtFIHXqOHnpDeHDuYrfEY6UlojDUu24jVwjfKGJVuxrJnLthMEGmo0Xgvdfl0akmzFc6euvCHJ1k5Zcw+2bRPwSXSf5FeOeLXpbRLWXQJz1L2XwrdJm4MeUGjzxc//YcVXVpzozGC5sliHcGIINNRNvOjlzrFc2cSMlF58C7gu/Vby+XaGZMv5JlfW3JttJwksVeP21xbpUeljki13DcyVNfdmO54ErldjT0i+G+I7i49Ltty5M9ayZstsIQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIBAxwjE1wD5xbd+nUJM36T4QukHUqftLHXwrZJOjlWeP97uV3Fslfwy3vjqG0W7ZnX1fErXeqdjCEAAAhCAAAQgME4EamrnX+PUVrvNeJI5WLKT38N2apLv73z6jf3dtroGwASw216gfwhUlADfAq6oYxgWBCDwfxNYrJobQ+2aQk8Qr5Yekf4geYXwO5JflOvPm71eirZCEedtku6SPHkrs6nKfK+0oaRwrvL8otdof1VkV0jMVPhdyX24/29LbsvmLzbcKjnfukqy+UW9P5Y8sfSK4vlStIYiK6V7pe3SFVK0YxTxi9J9LJ6sHixFc73fS3HldF4sIIQABCAAAQhAAAJVJ1DTAD3BS22xEukEcL/SHw0VPq9wt3R8SK9SeG2In6vQE8ODQvo8hT8J8WLwIWX8sJgZ0pco3CP9SrpGWiBFc/tu1+ZvjH9PusgJ2QbJ44s2O0R8W/vLIe6VRE8o3xnSDYXXhbjrPyt5ImnzJxOXjcYGBt6l8CXpFGmWZAaHSLbpUjo5HM1kAwEIQAACEIAABKpKoKaBHWgC+Hwy+JMV9ypatE8qsi4kblb4FymuinnFzfEy88TxrLKCkOdVO3+Wy88IejJ4jmTbJXl1L/bxR8Xd1gzpRWmKVLSnlTEnyfy64peFdEPhwhB34FXOE6RDJbeX3tVxn54AeoLr5xJvkz4tpW0riUEAAv1IoOzi048cOGYIQGDyEPBEKJpXwUZiQqHT8brnFbmrpdVSzlzPz/59IVPpnyr7UdAOhR+XvJLnfU+XPNFMzRPAnHkVM7U03ep40jrpvj5mrwi+R1os3S8tle6RMAhAoE8JpH8t9ikCDhsCEOhTAnfquC+QDg/H72fzFoR4Gvj2q5+f88pemZ2hzPhcnyeXx0nbQkX3cakUJ52+HTtfclu/kS6SosVbwL9Uxvkh03lu/+6QbhU8p4KtkieeNo/52NHYwMBMhV6h9ITvKsn9LpAwCECgjwkwAexj53PoEOhzAjfq+NdKdWmL5FumJ0lF8wTsjmJmkl6iuCdfj0puxyuQKyXb56R9ktt2uSd3Ncl2nuSVucck77dcsl0oeRLp+hskP1f4oHQg+4QquI1NkieQD0i2V0q3S77F7TY9Wb1BwiAAAQhAAAIQgAAEWhDwBO2IFmVkQwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgECvE/gvP3yjSFXpri4AAAAASUVORK5CYII=\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TCLab disconnected successfully.\n"
     ]
    }
   ],
   "source": [
    "experiment = runexperiment(steptest, connected=True, \n",
    "                           plot=True, twindow=1000,\n",
    "                           time=1000, \n",
    "                           speedup=1,\n",
    "                           dbfile='sinetest.db')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# h = experiment.historian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tclab import Historian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "h = Historian(sources=(('Q1', lambda: [1, 2, 3, 4]), ('Q2', None), ('T1', None), ('T2', None)), dbfile='sinetest.db')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, '2018-03-06 18:45:27', 13710),\n",
       " (12, '2018-03-07 14:55:43', 2001),\n",
       " (15, '2018-03-07 18:43:39', 7526),\n",
       " (25, '2018-03-08 05:34:09', 5523),\n",
       " (27, '2018-03-08 07:10:23', 4873),\n",
       " (28, '2018-03-08 12:59:29', 55),\n",
       " (29, '2018-03-08 13:00:31', 116),\n",
       " (30, '2018-03-08 13:02:35', 1001),\n",
       " (31, '2018-03-08 13:25:17', 2001),\n",
       " (32, '2018-03-08 14:30:19', 0),\n",
       " (33, '2018-03-08 14:30:32', 891),\n",
       " (34, '2018-03-08 14:46:08', 536),\n",
       " (35, '2018-03-08 14:55:18', 132),\n",
       " (36, '2018-03-08 15:02:28', 2001),\n",
       " (37, '2018-03-09 04:37:56', 0),\n",
       " (38, '2018-03-09 04:39:17', 0)]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.get_sessions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "h.load_session(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "tau_p = 150\n",
    "K_p = 0.38\n",
    "theta = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "T1_0 = 43"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = numpy.array(h.t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "resp = numpy.maximum(deltaQ*K_p*(1 - numpy.exp(-(t - theta - steptime)/tau_p)), 0) + T1_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40, 48.603)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10c2b29e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(h.t, h.logdict['T1'])\n",
    "plt.plot(h.t, resp)\n",
    "plt.ylim(ymin=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}